const api = require('../../utils/api.js');
const storage = require('../../utils/storage.js');
const level = require('../../utils/level.js'); // 🎯 引入等级工具
const imageUtil = require('../../utils/image.js'); // 📸 引入图片处理工具

Page({
  data: {
    participants: [],
    isLoading: true,
    isReviewing: false
  },

  onLoad() {
    console.log('📱 =============== 活动申请用户管理页面加载 ===============');
    this.loadParticipants();
  },

  onShow() {
    // 🔔 自动初始化通知组件
    const app = getApp();
    app.autoInitNotification();
  },

  /**
   * 加载参与者数据
   */
  async loadParticipants() {
    try {
      const userData = storage.getUserInfo();
      if (!userData) {
        wx.showToast({
          title: '请先登录',
          icon: 'none'
        });
        setTimeout(() => {
          wx.navigateBack();
        }, 1500);
        return;
      }

      this.setData({ isLoading: true });
      console.log('🔄 开始加载发布者活动参与者数据...');
      console.log('👤 发布者ID:', userData.userid);

      const response = await api.getPublisherActivityParticipants(userData.userid);
      
      console.log('📊 API响应:', response);
      
      if (response.status === 'success' && response.data) {
        // 处理参与者数据，添加排序
        let participants = response.data.participants || [];
        
        // 🔥 处理数据：标准化状态和计算等级
        participants = participants.map(p => {
          // 🔥 处理状态：优先使用 reviewStatus 字段（后端返回的审核结果）
          let status;
          if (p.reviewStatus) {
            // 根据 reviewStatus 映射状态
            if (p.reviewStatus === '通过' || p.reviewStatus === 'approved') {
              status = '已通过';
            } else if (p.reviewStatus === '未通过' || p.reviewStatus === 'rejected') {
              status = '已拒绝';
            } else {
              status = '待审核';
            }
          } else {
            // 如果没有 reviewStatus，使用 participantStatus
            status = p.participantStatus;
            if (Array.isArray(status)) {
              status = status[0] || 'pending';  // 取数组第一个元素
            }
          }
          
          // 🔥 使用等级工具类计算等级名称
          const levelName = level.getLevelNameFromPoints(p.userPoints || 0);
          
          // 🔥 根据生日计算年龄
          const age = this.calculateAge(p.userBirthday);
          
          // 📸 处理用户头像URL（HTTP转HTTPS，处理无效URL）
          const processedAvatar = imageUtil.processAvatar(p.userAvatar);
          
          // 🔥 建立 ID → 手机号 映射关系（用于融云IM发送消息）
          if (p.userId && p.userPhone) {
            const idToPhoneMap = storage.get('id_to_phone_map') || {};
            idToPhoneMap[p.userId] = p.userPhone;
            storage.set('id_to_phone_map', idToPhoneMap);
            console.log('✅ 建立映射: 用户ID', p.userId, '→ 手机号', p.userPhone);
          }
          
          return {
            ...p,
            participantStatus: status,  // 标准化后的状态（字符串）
            levelName: levelName,       // 计算的等级名称
            age: age,                   // 计算的年龄
            userAvatar: processedAvatar // 处理后的头像URL
          };
        });
        
        // 按状态排序：待审核 > 已通过 > 已拒绝
        participants.sort((a, b) => {
          const getStatusPriority = (status) => {
            if (status === 'pending' || status === '待审核' || status === '审核中') return 0;
            if (status === 'approved' || status === '已通过') return 1;
            if (status === 'rejected' || status === '已拒绝') return 2;
            return 3;
          };
          
          const priorityA = getStatusPriority(a.participantStatus);
          const priorityB = getStatusPriority(b.participantStatus);
          
          if (priorityA !== priorityB) {
            return priorityA - priorityB;
          }
          
          // 相同状态按申请时间倒序（iOS兼容格式）
          const timeA = (a.joinTime || a.applicationTime || '').replace(/ /g, 'T');
          const timeB = (b.joinTime || b.applicationTime || '').replace(/ /g, 'T');
          return new Date(timeB) - new Date(timeA);
        });

        this.setData({ participants });
        
        console.log('✅ 参与者数据加载成功');
        console.log('👥 总参与者数:', participants.length);
        console.log('⏳ 待审核:', participants.filter(p => p.participantStatus === 'pending' || p.participantStatus === '待审核' || p.participantStatus === '审核中').length);
        console.log('✅ 已通过:', participants.filter(p => p.participantStatus === 'approved' || p.participantStatus === '已通过').length);
        console.log('❌ 已拒绝:', participants.filter(p => p.participantStatus === 'rejected' || p.participantStatus === '已拒绝').length);
      } else {
        console.log('❌ 参与者数据加载失败:', response.message);
        wx.showToast({
          title: response.message || '加载失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('💥 加载参与者数据异常:', error);
      wx.showToast({
        title: '加载失败',
        icon: 'none'
      });
    } finally {
      this.setData({ isLoading: false });
    }
  },

  /**
   * 下拉刷新
   */
  onPullDownRefresh() {
    console.log('🔄 下拉刷新...');
    this.loadParticipants().then(() => {
      wx.stopPullDownRefresh();
    });
  },

  /**
   * 显示操作菜单
   */
  showActionMenu(e) {
    const { index } = e.currentTarget.dataset;
    const participant = this.data.participants[index];
    
    // 只有待审核状态才显示操作菜单
    if (participant.participantStatus !== 'pending' && 
        participant.participantStatus !== '待审核' && 
        participant.participantStatus !== '审核中') {
      return;
    }

    const that = this;
    wx.showActionSheet({
      itemList: ['同意', '拒绝', '举报'],
      success(res) {
        if (res.tapIndex === 0) {
          // 同意
          that.approveApplication(participant);
        } else if (res.tapIndex === 1) {
          // 拒绝
          that.rejectApplication(participant);
        } else if (res.tapIndex === 2) {
          // 举报
          wx.showToast({
            title: '举报功能开发中',
            icon: 'none'
          });
        }
      }
    });
  },

  /**
   * 通过申请
   */
  async approveApplication(participant) {
    if (this.data.isReviewing) {
      console.log('⚠️ 正在审核中，请稍后');
      return;
    }

    try {
      this.setData({ isReviewing: true });
      
      console.log('🔄 开始通过申请...');
      console.log('👤 用户:', participant.userName, '(', participant.userId, ')');
      console.log('🎯 活动:', participant.activityTitle, '(', participant.activityId, ')');

      const response = await api.reviewParticipantApplication(
        participant.activityId,
        participant.userId,
        '通过'
      );

      if (response.status === 'success') {
        console.log('✅ 申请通过成功');
        
        wx.showToast({
          title: `已允许 ${participant.userName} 加入活动`,
          icon: 'success'
        });

        // 🔥 发送融云IM实时通知给申请者
        this.sendReviewNotification(participant, '通过');

        // 重新加载数据
        await this.loadParticipants();
      } else {
        console.log('❌ 申请通过失败:', response.message);
        wx.showToast({
          title: response.message || '审核失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('💥 通过申请异常:', error);
      wx.showToast({
        title: '审核失败',
        icon: 'none'
      });
    } finally {
      this.setData({ isReviewing: false });
    }
  },

  /**
   * 拒绝申请
   */
  async rejectApplication(participant) {
    if (this.data.isReviewing) {
      console.log('⚠️ 正在审核中，请稍后');
      return;
    }

    try {
      this.setData({ isReviewing: true });
      
      console.log('🔄 开始拒绝申请...');
      console.log('👤 用户:', participant.userName, '(', participant.userId, ')');
      console.log('🎯 活动:', participant.activityTitle, '(', participant.activityId, ')');

      const response = await api.reviewParticipantApplication(
        participant.activityId,
        participant.userId,
        '未通过'
      );

      if (response.status === 'success') {
        console.log('✅ 申请拒绝成功');
        
        wx.showToast({
          title: `已拒绝 ${participant.userName} 的申请`,
          icon: 'success'
        });

        // 🔥 发送融云IM实时通知给申请者
        this.sendReviewNotification(participant, '未通过');

        // 重新加载数据
        await this.loadParticipants();
      } else {
        console.log('❌ 申请拒绝失败:', response.message);
        wx.showToast({
          title: response.message || '审核失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('💥 拒绝申请异常:', error);
      wx.showToast({
        title: '审核失败',
        icon: 'none'
      });
    } finally {
      this.setData({ isReviewing: false });
    }
  },

  /**
   * 🔥 查看用户信息
   */
  goToUserProfile(e) {
    const { userid } = e.currentTarget.dataset;
    console.log('🔗 =============== 点击头像跳转用户主页 ===============');
    console.log('👤 目标用户ID:', userid);
    
    if (!userid) {
      wx.showToast({
        title: '用户信息不存在',
        icon: 'none'
      });
      return;
    }
    
    // 🔥 跳转到用户信息页面
    wx.navigateTo({
      url: `/pages/user-info/index?userId=${userid}`,
      success: () => {
        console.log('✅ 跳转用户主页成功');
      },
      fail: (err) => {
        console.error('❌ 跳转用户主页失败:', err);
        wx.showToast({
          title: '跳转失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 根据性别获取图标
   */
  getGenderIcon(gender) {
    switch (gender) {
      case '男':
        return '♂';
      case '女':
        return '♀';
      default:
        return '?';
    }
  },

  /**
   * 根据生日计算年龄
   */
  calculateAge(birthday) {
    if (!birthday) return 0;
    
    try {
      const birthDate = new Date(birthday);
      const now = new Date();
      
      let age = now.getFullYear() - birthDate.getFullYear();
      
      // 检查是否还没到今年的生日
      if (now.getMonth() < birthDate.getMonth() || 
          (now.getMonth() === birthDate.getMonth() && now.getDate() < birthDate.getDate())) {
        age--;
      }
      
      return age;
    } catch (e) {
      console.log('⚠️ 生日解析失败:', birthday, e);
      return 0;
    }
  },

  /**
   * 格式化申请时间
   */
  formatApplicationTime(timeString) {
    if (!timeString) return '';
    
    try {
      // 如果已经是格式化的时间字符串，直接返回
      if (timeString.includes('-') && timeString.includes(':')) {
        return timeString;
      }
      
      // 如果是时间戳，进行转换
      const timestamp = parseInt(timeString);
      if (timestamp) {
        const date = new Date(timestamp * 1000);
        const year = date.getFullYear();
        const month = String(date.getMonth() + 1).padStart(2, '0');
        const day = String(date.getDate()).padStart(2, '0');
        const hour = String(date.getHours()).padStart(2, '0');
        const minute = String(date.getMinutes()).padStart(2, '0');
        const second = String(date.getSeconds()).padStart(2, '0');
        
        return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
      }
      
      return timeString;
    } catch (e) {
      console.log('⚠️ 时间格式化失败:', e);
      return timeString;
    }
  },

  /**
   * 获取状态颜色
   */
  getStatusColor(status) {
    if (status === 'pending' || status === '待审核') {
      return '#FF9800'; // 橙色
    } else if (status === 'approved' || status === '已通过') {
      return '#4CAF50'; // 绿色
    } else if (status === 'rejected' || status === '已拒绝') {
      return '#F44336'; // 红色
    }
    return '#9E9E9E'; // 灰色
  },

  /**
   * 获取状态文字
   */
  getStatusText(status) {
    if (status === 'pending' || status === '待审核') {
      return '待审核';
    } else if (status === 'approved' || status === '已通过') {
      return '已通过';
    } else if (status === 'rejected' || status === '已拒绝') {
      return '已拒绝';
    }
    return '未知';
  },

  /**
   * 🔥 发送审核结果实时通知（通过融云IM）
   * @param {Object} participant - 参与者对象
   * @param {string} reviewResult - 审核结果（'通过' 或 '未通过'）
   */
  async sendReviewNotification(participant, reviewResult) {
    console.log('📤 =============== 发送审核结果实时通知 ===============');
    console.log('👤 接收者:', participant.userName, '(ID:', participant.userId, ')');
    console.log('🎯 活动:', participant.activityTitle);
    console.log('✅ 审核结果:', reviewResult);

    try {
      // 🔥 获取融云工具类
      const rongcloud = require('../../utils/rongcloud.js');
      
      // 🔥 检查融云连接状态
      const isConnected = rongcloud.getConnectionStatus();
      if (!isConnected) {
        console.warn('⚠️ 融云未连接，无法发送实时通知');
        console.warn('💡 提示：通知将通过后端API发送（降级方案）');
        
        // 降级方案：调用后端API发送通知
        try {
          await api.sendActivityReviewResult(
            participant.userId,
            participant.activityTitle || '活动',
            reviewResult
          );
          console.log('✅ 通过后端API发送通知成功');
        } catch (error) {
          console.error('❌ 后端API发送通知失败:', error);
        }
        return;
      }

      // 🔥 关键：需要获取申请者的手机号（融云用户ID）
      // 方案1：从participant对象中获取（如果后端返回了）
      let receiverPhone = participant.userPhone || participant.phone;
      
      // 方案2：如果没有手机号，尝试从本地映射表反查
      if (!receiverPhone) {
        console.log('⚠️ 参与者数据中没有手机号，尝试从映射表查找...');
        
        // 从本地存储的ID→手机号映射表中查找
        const idToPhoneMap = storage.get('id_to_phone_map') || {};
        receiverPhone = idToPhoneMap[participant.userId];
        
        if (!receiverPhone) {
          console.error('❌ 无法获取申请者手机号，无法发送融云消息');
          console.error('💡 提示：请确保后端API返回了用户手机号字段');
          
          // 降级方案：调用后端API
          try {
            await api.sendActivityReviewResult(
              participant.userId,
              participant.activityTitle || '活动',
              reviewResult
            );
            console.log('✅ 通过后端API发送通知成功（降级）');
          } catch (error) {
            console.error('❌ 后端API发送通知失败:', error);
          }
          return;
        }
      }

      console.log('📱 申请者手机号（融云用户ID）:', receiverPhone);

      // 🔥 构建消息内容
      const activityTitle = participant.activityTitle || '活动';
      let messageContent;
      let resultEmoji;
      
      if (reviewResult === '通过') {
        resultEmoji = '✅';
        messageContent = `${resultEmoji} 您申请加入的活动「${activityTitle}」已通过审核！\n\n快去查看活动详情吧～`;
      } else {
        resultEmoji = '❌';
        messageContent = `${resultEmoji} 很抱歉，您申请加入的活动「${activityTitle}」未通过审核。\n\n请继续关注其他精彩活动！`;
      }

      console.log('📝 消息内容:', messageContent);

      // 🔥 发送融云IM消息
      const result = await rongcloud.sendTextMessage(receiverPhone, messageContent);
      
      console.log('✅ 融云IM通知发送成功');
      console.log('📨 消息ID:', result.messageId);
      console.log('⏰ 发送时间:', result.sentTime);
      
      // 🎉 发送成功提示
      wx.showToast({
        title: '已实时通知申请者',
        icon: 'success',
        duration: 1500
      });

    } catch (error) {
      console.error('💥 发送审核结果通知失败:', error);
      console.error('错误详情:', error.message || error);
      
      // 发送失败时的降级方案：调用后端API
      console.log('🔄 尝试通过后端API发送通知（降级方案）...');
      try {
        await api.sendActivityReviewResult(
          participant.userId,
          participant.activityTitle || '活动',
          reviewResult
        );
        console.log('✅ 通过后端API发送通知成功（降级）');
      } catch (apiError) {
        console.error('❌ 后端API也发送失败:', apiError);
      }
    }
  }
});

